import apiClient from "@/lib/interceptor";
import qs from 'qs';

/**
 * 面试详情查询参数接口
 */
interface InterviewSituationParams {
  page?: number;           // 当前页
  pageSize?: number;       // 页面大小
  interviewId?: number;    // 面试id
  intervieweeId?: number;  // 应聘者id
}

/**
 * 面试详情信息接口
 */
interface InterviewSituation {
  id: number;                   // 主键id
  interviewId: number;          // 面试id
  intervieweeId: number;        // 应聘者id
  name: string;                 // 应聘者姓名
  professionalSkills: number;   // 专业技能评分
  communicationSkills: number;  // 沟通能力评分
  teamworkAbility: number;      // 团队协作评分
  overallRating: number;        // 综合评分
  comments?: string;            // 评价内容
  notes?: string;              // 备注
  createTime: string;          // 创建时间
  updateTime: string;          // 更新时间
  status: number;              // 状态
  result: number;              // 面试结果
}

/**
 * 面试安排参数接口
 */
interface InterviewSchedule {
  planId: number;           // 招聘计划id
  deptId: string;          // 招聘部门编号
  positionNumber: string;   // 招聘岗位编号
  interviewerIds: string;   // 面试官工号列表，用逗号分隔
  interviewRound: number;   // 面试轮次
  name: string;            // 面试名称
  place: string;           // 面试地点
  recruitsNumber: number;   // 预计招聘人数
  startTime: string;       // 开始时间
  endTime: string;         // 结束时间
}

/**
 * 面试安排查询参数接口
 */
interface InterviewQueryParams {
  page?: number;           // 当前页
  pageSize?: number;       // 页面大小
  startTime?: string;      // 开始时间
  endTime?: string;        // 结束时间
}

/**
 * 应聘者简要信息接口
 */
interface IntervieweeInfo {
  id: number;              // 应聘者id
  name: string;            // 姓名
  email: string;           // 邮箱
  phone: string;           // 电话
  interviewStatus: number; // 面试状态
}

/**
 * 面试安排详情接口
 */
interface InterviewDetail {
  id: number;                   // 面试id
  planId: number;               // 招聘计划id
  deptId: string;              // 招聘部门编号
  positionNumber: string;       // 招聘岗位编号
  interviewerIds: string;       // 面试官工号列表
  interviewRound: number;       // 面试轮次
  name: string;                // 面试名称
  place: string;               // 面试地点
  recruitsNumber: number;       // 预计招聘人数
  interviewNumber: number;      // 面试人数
  throughNumber: number;        // 通过人数
  startTime: string;           // 开始时间
  endTime: string;             // 结束时间
  createTime: string;          // 创建时间
  updateTime: string;          // 更新时间
  createBy: string;            // 创建人
  updateBy: string;            // 更新人
  intervieweeMsg: IntervieweeInfo[]; // 应聘者信息列表
}

/**
 * 调整面试安排参数接口
 */
interface InterviewUpdateParams {
  interviewerIds?: string;   // 面试官工号列表
  interviewRound?: number;   // 面试轮次
  name?: string;            // 面试名称
  place?: string;           // 面试地点
  recruitsNumber?: number;   // 预计招聘人数
  startTime?: string;       // 开始时间
  endTime?: string;         // 结束时间
}

/**
 * 面试开始或结束请求参数接口
 */
interface InterviewStartEndParams {
  interviewId: number;  // 面试ID
  startOrEnd: number;   // 1为开始，2为结束
}

/**
 * 查询面试详情
 * @description 获取面试评价详情列表，可按面试ID或应聘者ID筛选
 * 
 * @param params - 查询参数，包含页码、每页数量、面试ID和应聘者ID
 * @returns Promise<{ code: number; msg: string; data: { total: number; row: InterviewSituation[] } }>
 * 
 * @example
 * ```typescript
 * // 查询所有面试详情
 * const response = await getInterviewSituations({
 *   page: 1,
 *   pageSize: 10
 * });
 * 
 * // 查询指定面试的详情
 * const response = await getInterviewSituations({
 *   interviewId: 23,
 *   page: 1,
 *   pageSize: 10
 * });
 * 
 * if (response.code === 1) {
 *   const { total, row } = response.data;
 *   console.log(`共 ${total} 条记录`);
 *   console.log('面试详情:', row);
 * }
 * ```
 */
export const getInterviewSituations = async (params: InterviewSituationParams) => {
  try {
    // 构建查询参数
    const queryParams = new URLSearchParams();
    if (params.page) queryParams.append('page', params.page.toString());
    if (params.pageSize) queryParams.append('pageSize', params.pageSize.toString());
    if (params.interviewId) queryParams.append('interviewId', params.interviewId.toString());
    if (params.intervieweeId) queryParams.append('intervieweeId', params.intervieweeId.toString());

    // 发送请求
    const response = await apiClient.get(`/interview/situation?${queryParams.toString()}`);

    // 打印响应数据
    console.log('面试详情响应:', {
      params,
      response: response.data
    });

    return response.data;
  } catch (error) {
    console.error('获取面试详情失败:', error);
    throw error;
  }
};

/**
 * 计算平均分数
 * @param scores - 分数数组
 * @returns number 平均分数，保留2位小数
 */
export const calculateAverageScore = (scores: number[]) => {
  if (!scores.length) return 0;
  const sum = scores.reduce((acc, curr) => acc + curr, 0);
  return Number((sum / scores.length).toFixed(2));
};

/**
 * 获取面试结果文本
 * @param result - 面试结果代码
 * @returns string 结果文本
 */
export const getInterviewResultText = (result: number): string => {
  switch (result) {
    case 1:
      return '通过';
    case 2:
      return '未通过';
    case 3:
      return '待定';
    default:
      return '未知';
  }
};

/**
 * 新增面试安排
 * @description 创建新的面试安排
 * 
 * @param schedule - 面试安排信息
 * @returns Promise<{ code: number; msg: string; data: null }>
 * 
 * @example
 * ```typescript
 * try {
 *   const response = await createInterview({
 *     planId: 8,
 *     deptId: "D001",
 *     positionNumber: "P001",
 *     interviewerIds: "0000000,1111111",
 *     interviewRound: 1,
 *     name: "前端开发工程师一面",
 *     place: "科技楼503",
 *     recruitsNumber: 2,
 *     startTime: "2024-02-20T14:00:00",
 *     endTime: "2024-02-20T16:00:00"
 *   });
 * 
 *   if (response.code === 1) {
 *     message.success('面试安排创建成功');
 *   }
 * } catch (error) {
 *   console.error('创建面试安排失败:', error);
 * }
 * ```
 */
export const createInterview = async (schedule: InterviewSchedule) => {
  try {
    // 打印请求参数
    console.log('创建面试安排请求:', schedule);

    // 发送请求
    const response = await apiClient.post('/interview', schedule, {
      headers: {
        'Content-Type': 'application/json'
      }
    });

    // 打印响应数据
    console.log('创建面试安排响应:', response.data);

    return response.data;
  } catch (error) {
    console.error('创建面试安排失败:', error);
    throw error;
  }
};

/**
 * 格式化面试时间
 * @param date - 日期对象
 * @returns string 格式化后的时间字符串
 */
export const formatInterviewTime = (date: Date): string => {
  return date.toISOString().slice(0, 19).replace('T', ' ');
};

/**
 * 验证面试时间
 * @param startTime - 开始时间
 * @param endTime - 结束时间
 * @returns boolean 时间是否有效
 */
export const validateInterviewTime = (startTime: string, endTime: string): boolean => {
  const start = new Date(startTime);
  const end = new Date(endTime);
  const now = new Date();

  return start > now && end > start;
};

/**
 * 查询个人面试安排列表
 * @description 获取当前面试官的面试安排列表
 * 
 * @param params - 查询参数，包含页码、每页数量、时间范围
 * @returns Promise<{ code: number; msg: string; data: { total: number; row: InterviewDetail[] } }>
 * 
 * @example
 * ```typescript
 * try {
 *   const response = await getInterviews({
 *     page: 1,
 *     pageSize: 10,
 *     startTime: '2024-02-20 00:00:00',
 *     endTime: '2024-02-21 00:00:00'
 *   });
 * 
 *   if (response.code === 1) {
 *     const { total, row } = response.data;
 *     console.log(`共 ${total} 条记录`);
 *     console.log('面试安排列表:', row);
 *   }
 * } catch (error) {
 *   console.error('获取面试安排失败:', error);
 * }
 * ```
 */
export const getInterviews = async (params: InterviewQueryParams) => {
  try {
    // 构建查询参数
    const queryParams = new URLSearchParams();
    if (params.page) queryParams.append('page', params.page.toString());
    if (params.pageSize) queryParams.append('pageSize', params.pageSize.toString());
    if (params.startTime) queryParams.append('startTime', params.startTime);
    if (params.endTime) queryParams.append('endTime', params.endTime);

    // 发送请求
    const response = await apiClient.get(`/interview?${queryParams.toString()}`);

    // 打印响应数据
    console.log('面试安排列表响应:', {
      params,
      response: response.data
    });

    return response.data;
  } catch (error) {
    console.error('获取面试安排失败:', error);
    throw error;
  }
};

/**
 * 查询所有面试安排列表
 * @description 获取所有面试安排列表（管理员权限）
 * 
 * @param params - 查询参数，包含页码、每页数量、时间范围
 * @returns Promise<{ code: number; msg: string; data: { total: number; row: InterviewDetail[] } }>
 * 
 * @example
 * ```typescript
 * try {
 *   const response = await getAllInterviews({
 *     page: 1,
 *     pageSize: 10,
 *     startTime: '2024-02-20 00:00:00',
 *     endTime: '2024-02-21 00:00:00'
 *   });
 * 
 *   if (response.code === 1) {
 *     const { total, row } = response.data;
 *     console.log(`共 ${total} 条记录`);
 *     console.log('所有面试安排:', row);
 *   }
 * } catch (error) {
 *   console.error('获取所有面试安排失败:', error);
 * }
 * ```
 */
export const getAllInterviews = async (params: InterviewQueryParams) => {
  try {
    // 构建查询参数
    const queryParams = new URLSearchParams();
    if (params.page) queryParams.append('page', params.page.toString());
    if (params.pageSize) queryParams.append('pageSize', params.pageSize.toString());
    if (params.startTime) queryParams.append('startTime', params.startTime);
    if (params.endTime) queryParams.append('endTime', params.endTime);

    // 发送请求
    const response = await apiClient.get(`/interview/all?${queryParams.toString()}`);

    // 打印响应数据
    console.log('所有面试安排列表响应:', {
      params,
      response: response.data
    });

    return response.data;
  } catch (error) {
    console.error('获取所有面试安排失败:', error);
    throw error;
  }
};

/**
 * 获取面试状态文本
 * @param status - 面试状态码
 * @returns string 状态文本
 */
export const getInterviewStatusText = (status: number): string => {
  switch (status) {
    case 0:
      return '待面试';
    case 1:
      return '面试中';
    case 2:
      return '已完成';
    case 3:
      return '已取消';
    default:
      return '未知状态';
  }
};

/**
 * 格式化面试官ID列表
 * @param ids - 面试官ID字符串
 * @returns string[] 面试官ID数组
 */
export const formatInterviewerIds = (ids: string): string[] => {
  return ids.split(',').filter(id => id.trim());
};

/**
 * 取消面试安排
 * @description 取消一个或多个面试安排
 * 
 * @param interviewIds - 要取消的面试ID数组
 * @returns Promise<{ code: number; msg: string; data: null }>
 * 
 * @example
 * ```typescript
 * try {
 *   const response = await cancelInterviews([1, 2, 3]);
 * 
 *   if (response.code === 1) {
 *     message.success('面试已取消');
 *   }
 * } catch (error) {
 *   console.error('取消面试失败:', error);
 * }
 * ```
 */
export const cancelInterviews = async (interviewIds: number[]) => {
  try {
    if (!interviewIds.length) {
      throw new Error('请选择要取消的面试');
    }

    // 打印请求参数
    console.log('取消面试请求:', {
      interviewIds,
      count: interviewIds.length
    });

    // 发送请求
    const response = await apiClient.delete(`/interview/${interviewIds.join(',')}`);

    // 打印响应数据
    console.log('取消面试响应:', response.data);

    return response.data;
  } catch (error) {
    console.error('取消面试失败:', error);
    throw error;
  }
};

/**
 * 批量操作面试安排
 * @description 批量取消或更新面试状态
 * 
 * @param action - 操作类型，'cancel' 或 'updateStatus'
 * @param ids - 要操作的面试ID数组
 * @param status - 新的面试状态（仅在 updateStatus 时需要）
 * @returns Promise<void>
 * 
 * @example
 * ```typescript
 * // 批量取消面试
 * await batchInterviewOperation('cancel', [1, 2, 3]);
 * ```
 */
export const batchInterviewOperation = async (
  action: 'cancel',
  ids: number[],
) => {
  try {
    if (!ids.length) {
      throw new Error('请选择要操作的面试');
    }

    let response;
    if (action === 'cancel') {
      response = await cancelInterviews(ids);
    }

    return response;
  } catch (error) {
    console.error('批量操作失败:', error);
    throw error;
  }
};

/**
 * 调整面试安排
 * @description 修改面试安排信息（会发送邮件通知）
 * 
 * @param interviewId - 面试ID
 * @param params - 更新的面试信息
 * @returns Promise<{ code: number; msg: string; data: null }>
 * 
 * @example
 * ```typescript
 * try {
 *   const response = await updateInterview(20, {
 *     interviewerIds: "0000000,1111111",
 *     place: "科技楼503",
 *     startTime: "2024-02-20T14:00:00",
 *     endTime: "2024-02-20T16:00:00"
 *   });
 * 
 *   if (response.code === 1) {
 *     message.success('面试安排已更新');
 *   }
 * } catch (error) {
 *   console.error('更新面试安排失败:', error);
 * }
 * ```
 */
export const updateInterview = async (interviewId: number, params: InterviewUpdateParams) => {
  try {
    // 打印请求参数
    console.log('更新面试安排请求:', {
      interviewId,
      params
    });

    // 发送请求
    const response = await apiClient.patch('/interview', {
      interviewId,
      ...params
    }, {
      headers: {
        'Content-Type': 'application/json'
      }
    });

    // 打印响应数据
    console.log('更新面试安排响应:', response.data);

    return response.data;
  } catch (error) {
    console.error('更新面试安排失败:', error);
    throw error;
  }
};

/**
 * 更新面试评估情况
 * @description 更新面试者的评估信息，包括专业技能、沟通能力等评分（会发送邮件通知）
 * 
 * @param params - 评估信息参数
 * @returns Promise<{ code: number; msg: string; data: null }>
 * 
 * @example
 * ```typescript
 * try {
 *   const response = await updateInterviewSituation({
 *     id: 57,
 *     professionalSkills: 4,    // 1-5分会被转换为0-100分
 *     communicationSkills: 5,    // 1-5分会被转换为0-100分
 *     teamworkAbility: 3,       // 1-5分会被转换为0-100分
 *     comments: '技术基础扎实',
 *     notes: '建议入职',
 *     status: 1,
 *     result: 1
 *   });
 *   
 *   if (response.code === 1) {
 *     message.success('评估更新成功');
 *   }
 * } catch (error) {
 *   console.error('更新评估失败:', error);
 * }
 * ```
 */
export const updateInterviewSituation = async (params: {
  id: number;                    // 主键id
  professionalSkills: number;    // 专业技能（1-5分，会被转换为0-100分）
  communicationSkills: number;   // 沟通能力（1-5分，会被转换为0-100分）
  teamworkAbility: number;       // 团队协作（1-5分，会被转换为0-100分）
  comments?: string;             // 评价意见
  notes?: string;               // 备注
  status: number;               // 面试状态（0待面试，1已面试，2已取消，3未到场）
  result: number;               // 面试结果（0待定，1通过，2不通过）
}) => {
  try {
    // 将1-5分转换为0-100分
    const convertToPercentage = (score: number) => Math.round((score / 5) * 100);

    const convertedParams = {
      ...params,
      professionalSkills: convertToPercentage(params.professionalSkills),
      communicationSkills: convertToPercentage(params.communicationSkills),
      teamworkAbility: convertToPercentage(params.teamworkAbility)
    };

    // 打印转换后的参数
    console.log('评分转换:', {
      原始评分: {
        专业技能: params.professionalSkills,
        沟通能力: params.communicationSkills,
        团队协作: params.teamworkAbility
      },
      转换后评分: {
        专业技能: convertedParams.professionalSkills,
        沟通能力: convertedParams.communicationSkills,
        团队协作: convertedParams.teamworkAbility
      }
    });

    const response = await apiClient.patch('/interview/situation', convertedParams);
    return response.data;
  } catch (error) {
    console.error('更新面试评估失败:', error);
    throw error;
  }
};

/**
 * 开始或结束面试
 * @description 更新面试状态为开始或结束
 * 
 * @param params - 面试开始/结束参数
 * @returns Promise<{ code: number; msg: string; data: null }>
 * 
 * @example
 * ```typescript
 * try {
 *   // 开始面试
 *   const response = await startOrEndInterview({
 *     interviewId: 1,
 *     startOrEnd: 1
 *   });
 * 
 *   if (response.code === 1) {
 *     message.success('面试已开始');
 *   }
 * } catch (error) {
 *   console.error('操作失败:', error);
 * }
 * ```
 */
export const startOrEndInterview = async (params: InterviewStartEndParams) => {
  try {
    // 打印请求参数
    console.log('面试开始/结束请求:', params);

    // 发送请求
    const response = await apiClient.post('/interview/start', qs.stringify(params), {
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
      }
    });

    // 打印响应数据
    console.log('面试开始/结束响应:', response.data);

    return response.data;
  } catch (error) {
    console.error('操作失败:', error);
    throw error;
  }
};

export type { InterviewSituation, InterviewSituationParams, InterviewSchedule, InterviewQueryParams, InterviewDetail, IntervieweeInfo, InterviewUpdateParams };


